package com.zozo.guanli.dao;

import java.io.Serializable;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.transform.ResultTransformer;

import com.zozo.guanli.util.ReflectionUtils;

/**
 * 
 * 扩展功能包括分页查询,按属性过滤条件列表查询.
 * 可在Service层直接使用,也可以扩展泛型DAO子类使用,见两个构造函数的注释.
 * 
 * @param <T> DAO操作的对象类型
 * @param <PK> 主键类型
 * 
 * @author
 */
public class HibernateDao<T, PK extends Serializable> extends SimpleHibernateDao<T, PK> {
    /**
     * 用于Dao层子类的构造函数.
     * 通过子类的泛型定义取得对象类型Class.
     * eg.
     * public class UserDao extends HibernateDao<User, Long>{
     * }
     */
    public HibernateDao() {
        super();
    }

    /**
     * 用于省略Dao层, Service层直接使用通用HibernateDao的构造函数.
     * 在构造函数中定义对象类型Class.
     * eg.
     * HibernateDao<User, Long> userDao = new HibernateDao<User, Long>(sessionFactory, User.class);
     */
    public HibernateDao(final SessionFactory sessionFactory, final Class<T> entityClass) {
        super(sessionFactory, entityClass);
    }

    //-- 分页查询函数 --//

    /**
     * 分页获取全部对象.
     */
    //    public Page<T> getAll(final Page<T> page) {
    //        return findPage(page);
    //    }

    /**
     * 按HQL分页查询.
     * 
     * @param page 分页参数. 注意不支持其中的orderBy参数.
     * @param hql hql语句.
     * @param values 数量可变的查询参数,按顺序绑定.
     * 
     * @return 分页查询结果, 附带结果列表及所有查询输入参数.
     */
    //    @SuppressWarnings("unchecked")
    //    public Page<T> findPage(final Page<T> page, final String hql, final Object... values) {
    //        Assert.notNull(page, "page不能为空");
    //
    //        Query q = createQuery(hql, values);
    //
    //        if (page.isAutoCount()) {
    //            long totalCount = countHqlResult(hql, values);
    //            page.setTotalCount(totalCount);
    //        }
    //
    //        setPageParameterToQuery(q, page);
    //
    //        List result = q.list();
    //        page.setResult(result);
    //        return page;
    //    }
    /**
     * 按HQL分页查询.
     * 
     * @param page 分页参数. 注意不支持其中的orderBy参数.
     * @param hql hql语句.
     * @param values 命名参数,按名称绑定.
     * 
     * @return 分页查询结果, 附带结果列表及所有查询输入参数.
     */
    //    @SuppressWarnings("unchecked")
    //    public Page<T> findPage(final Page<T> page, final String hql, final Map<String, ?> values) {
    //        Assert.notNull(page, "page不能为空");
    //
    //        Query q = createQuery(hql, values);
    //
    //        if (page.isAutoCount()) {
    //            long totalCount = countHqlResult(hql, values);
    //            page.setTotalCount(totalCount);
    //        }
    //
    //        setPageParameterToQuery(q, page);
    //
    //        List result = q.list();
    //        page.setResult(result);
    //        return page;
    //    }

    /**
     * 按Criteria分页查询.
     * 
     * @param page 分页参数.
     * @param criterions 数量可变的Criterion.
     * 
     * @return 分页查询结果.附带结果列表及所有查询输入参数.
     */
    //    @SuppressWarnings("unchecked")
    //    public Page<T> findPage(final Page<T> page, final Criterion... criterions) {
    //        Assert.notNull(page, "page不能为空");
    //
    //        Criteria c = createCriteria(criterions);
    //
    //        if (page.isAutoCount()) {
    //            long totalCount = countCriteriaResult(c);
    //            page.setTotalCount(totalCount);
    //        }
    //
    //        setPageParameterToCriteria(c, page);
    //
    //        List result = c.list();
    //        page.setResult(result);
    //        return page;
    //    }

    /**
     * 设置分页参数到Query对象,辅助函数.
     */
    //    protected Query setPageParameterToQuery(final Query q, final Page<T> page) {
    //
    //        Assert.isTrue(page.getPageSize() > 0, "Page Size must larger than zero");
    //
    //        //hibernate的firstResult的序号从0开始
    //        q.setFirstResult(page.getFirst() - 1);
    //        q.setMaxResults(page.getPageSize());
    //        return q;
    //    }

    /**
     * 设置分页参数到Criteria对象,辅助函数.
     */
    //    protected Criteria setPageParameterToCriteria(final Criteria c, final Page<T> page) {
    //
    //        Assert.isTrue(page.getPageSize() > 0, "Page Size must larger than zero");
    //
    //        //hibernate的firstResult的序号从0开始
    //        c.setFirstResult(page.getFirst() - 1);
    //        c.setMaxResults(page.getPageSize());
    //
    //        if (page.isOrderBySetted()) {
    //            String[] orderByArray = StringUtils.split(page.getOrderBy(), ',');
    //            String[] orderArray = StringUtils.split(page.getOrder(), ',');
    //
    //            Assert.isTrue(orderByArray.length == orderArray.length, "分页多重排序参数中,排序字段与排序方向的个数不相等");
    //
    //            for (int i = 0; i < orderByArray.length; i++) {
    //                if (Page.ASC.equals(orderArray[i])) {
    //                    c.addOrder(Order.asc(orderByArray[i]));
    //                } else {
    //                    c.addOrder(Order.desc(orderByArray[i]));
    //                }
    //            }
    //        }
    //        return c;
    //    }

    /**
     * 执行count查询获得本次Hql查询所能获得的对象总数.
     * 
     * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
     */
    protected long countHqlResult(final String hql, final Object... values) {
        String countHql = prepareCountHql(hql);

        try {
            Long count = findUnique(countHql, values);
            return count;
        } catch (Exception e) {
            throw new RuntimeException("hql can't be auto count, hql is:" + countHql, e);
        }
    }

    /**
     * 执行count查询获得本次Hql查询所能获得的对象总数.
     * 
     * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
     */
    protected long countHqlResult(final String hql, final Map<String, ?> values) {
        String countHql = prepareCountHql(hql);

        try {
            Long count = findUnique(countHql, values);
            return count;
        } catch (Exception e) {
            throw new RuntimeException("hql can't be auto count, hql is:" + countHql, e);
        }
    }

    private String prepareCountHql(String orgHql) {
        String fromHql = orgHql;
        //select子句与order by子句会影响count查询,进行简单的排除.
        fromHql = "from " + StringUtils.substringAfter(fromHql, "from");
        fromHql = StringUtils.substringBefore(fromHql, "order by");

        String countHql = "select count(*) " + fromHql;
        return countHql;
    }

    /**
     * 执行count查询获得本次Criteria查询所能获得的对象总数.
     */
    @SuppressWarnings("unchecked")
    protected long countCriteriaResult(final Criteria c) {
        CriteriaImpl impl = (CriteriaImpl) c;

        // 先把Projection、ResultTransformer、OrderBy取出来,清空三者后再执行Count操作
        Projection projection = impl.getProjection();
        ResultTransformer transformer = impl.getResultTransformer();

        List<CriteriaImpl.OrderEntry> orderEntries = null;
        try {
            orderEntries = (List) ReflectionUtils.getFieldValue(impl, "orderEntries");
            ReflectionUtils.setFieldValue(impl, "orderEntries", new ArrayList());
        } catch (Exception e) {
            logger.error("不可能抛出的异常:{}", e.getMessage());
        }

        // 执行Count查询
        Long totalCountObject = (Long) c.setProjection(Projections.rowCount()).uniqueResult();
        long totalCount = (totalCountObject != null) ? totalCountObject : 0;

        // 将之前的Projection,ResultTransformer和OrderBy条件重新设回去
        c.setProjection(projection);

        if (projection == null) {
            c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
        }
        if (transformer != null) {
            c.setResultTransformer(transformer);
        }
        try {
            ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
        } catch (Exception e) {
            logger.error("不可能抛出的异常:{}", e.getMessage());
        }

        return totalCount;
    }

    //-- 属性过滤条件(PropertyFilter)查询函数 --//

    /**
     * 按属性查找对象列表,支持多种匹配方式.
     * 
     * @param matchType 匹配方式,目前支持的取值见PropertyFilter的MatcheType enum.
     */
    //    public List<T> findBy(final String propertyName, final Object value, final MatchType matchType) {
    //        Criterion criterion = buildCriterion(propertyName, value, matchType);
    //        return find(criterion);
    //    }

    /**
     * 按属性过滤条件列表查找对象列表.
     */
    //    public List<T> find(List<PropertyFilter> filters) {
    //        Criterion[] criterions = buildCriterionByPropertyFilter(filters);
    //        return find(criterions);
    //    }

    /**
     * 按属性过滤条件列表分页查找对象.
     */
    //    public Page<T> findPage(final Page<T> page, final List<PropertyFilter> filters) {
    //        Criterion[] criterions = buildCriterionByPropertyFilter(filters);
    //        return findPage(page, criterions);
    //    }

    /**
     * 按属性条件参数创建Criterion,辅助函数.
     */
    //    protected Criterion buildCriterion(final String propertyName, final Object propertyValue, final MatchType matchType) {
    //        Assert.hasText(propertyName, "propertyName不能为空");
    //        Criterion criterion = null;
    //        //根据MatchType构造criterion
    //        switch (matchType) {
    //            case EQ:
    //                criterion = Restrictions.eq(propertyName, propertyValue);
    //                break;
    //            case LIKE:
    //                criterion = Restrictions.like(propertyName, (String) propertyValue, MatchMode.ANYWHERE);
    //                break;
    //
    //            case LE:
    //                criterion = Restrictions.le(propertyName, propertyValue);
    //                break;
    //            case LT:
    //                criterion = Restrictions.lt(propertyName, propertyValue);
    //                break;
    //            case GE:
    //                criterion = Restrictions.ge(propertyName, propertyValue);
    //                break;
    //            case GT:
    //                criterion = Restrictions.gt(propertyName, propertyValue);
    //        }
    //        return criterion;
    //    }

    /**
     * 按属性条件列表创建Criterion数组,辅助函数.
     */
    //    protected Criterion[] buildCriterionByPropertyFilter(final List<PropertyFilter> filters) {
    //        List<Criterion> criterionList = new ArrayList<Criterion>();
    //        for (PropertyFilter filter : filters) {
    //            if (!filter.hasMultiProperties()) { //只有一个属性需要比较的情况.
    //                Criterion criterion = buildCriterion(filter.getPropertyName(), filter.getMatchValue(), filter.getMatchType());
    //                criterionList.add(criterion);
    //            } else {//包含多个属性需要比较的情况,进行or处理.
    //                Disjunction disjunction = Restrictions.disjunction();
    //                for (String param : filter.getPropertyNames()) {
    //                    Criterion criterion = buildCriterion(param, filter.getMatchValue(), filter.getMatchType());
    //                    disjunction.add(criterion);
    //                }
    //                criterionList.add(disjunction);
    //            }
    //        }
    //        return criterionList.toArray(new Criterion[criterionList.size()]);
    //    }

    //liulibo 2013/3/17 整理大家的DAO中加入的 排序 和 获取总数的方法。 TODO 是否可以用上面的放大代替？
    /**
     * 计算总条数 
     */
    protected int getTotal(String hql) {
        int fromIndex = hql.indexOf("from");
        hql = "select count(*) " + hql.substring(fromIndex);
        return ((Long) this.createQuery(hql).uniqueResult()).intValue();
    }

    /**
     * 计算总条数(SQL语句)
     * 
     * @param sql
     * @return
     */
    protected int getTotalBysql(String sql) {
        sql = "select count(*) from accessory a " + sql;
        return ((BigInteger) this.getSession().createSQLQuery(sql).list().get(0)).intValue();
    }

    /**
     * 公共的排序方法
     * @param sortParameter
     * @return
     */
    protected String sortCommon(Map<String, String> sortParameter) {
        StringBuffer sqlBuffer = new StringBuffer();
        //排序
        sqlBuffer.append(" order by ");
        Map<String, String> orderMap = sortParameter;
        Iterator<String> orderName = orderMap.keySet().iterator();
        int tempIndex = 0;
        while (orderName.hasNext()) {
            String orderBy = orderName.next();
            String by = orderMap.get(orderBy);
            sqlBuffer.append(orderBy + "  " + by + (tempIndex == orderMap.size() - 1 ? "" : ","));
        }
        return sqlBuffer.toString();
    }

    /**
     * 公共拼接参数方法
     * @param parameter
     * @return
     */
    protected String appendParameterCommon(Map<String, String> parameter) {
        StringBuffer sqlBuffer = new StringBuffer();
        Iterator<String> iterator = parameter.keySet().iterator();
        while (iterator.hasNext()) {
            String parKey = iterator.next();
            String parValue = parameter.get(parKey);

            String checkType = parKey.substring(0, parKey.indexOf("_"));
            String valType = parKey.substring(parKey.indexOf("_") + 1, parKey.indexOf("_") + 2);
            if (valType.equals("S")) {
                parValue = "'" + parValue + "'";
            }

            parKey = parKey.substring(parKey.indexOf("_") + 2);
            if (valType.equals("D")) { //时间类型 
                parValue = "to_date('" + parValue + "','yyyy-MM-dd hh24:mi:ss')";
            }

            if (checkType.equals("EQ")) {
                sqlBuffer.append(" and " + parKey + " = " + parValue);
            } else if (checkType.equals("LIKE")) {
                parValue = "'%" + parValue.toString().replace("'", "") + "%'";
                sqlBuffer.append(" and " + parKey + " like " + parValue);
            } else if (checkType.equals("LE")) {
                sqlBuffer.append(" and " + parKey + " <=" + parValue + " ");
            } else if (checkType.equals("GE")) {
                sqlBuffer.append(" and " + parKey + " >=" + parValue + " ");
            } else if (checkType.equals("LT")) {
                sqlBuffer.append(" and " + parKey + " <" + parValue + " ");
            } else if (checkType.equals("GT")) {
                sqlBuffer.append(" and " + parKey + " >" + parValue + " ");
            } else if (checkType.equals("IN")) {
                sqlBuffer.append(" and " + parKey + " in (" + parValue + " )");
            } else if (checkType.equals("NOT")) {
                sqlBuffer.append(" and " + parKey + "  <> (" + parValue + ")");
            }
        }
        return sqlBuffer.toString();
    }
    //end liulibo 2013/3/17 

}
